home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / gdata / tlslite / FileObject.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  5.8 KB  |  238 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Class returned by TLSConnection.makefile().'''
  5.  
  6. class FileObject:
  7.     '''This class provides a file object interface to a
  8.     L{tlslite.TLSConnection.TLSConnection}.
  9.  
  10.     Call makefile() on a TLSConnection to create a FileObject instance.
  11.  
  12.     This class was copied, with minor modifications, from the
  13.     _fileobject class in socket.py.  Note that fileno() is not
  14.     implemented.'''
  15.     default_bufsize = 16384
  16.     
  17.     def __init__(self, sock, mode = 'rb', bufsize = -1):
  18.         self._sock = sock
  19.         self.mode = mode
  20.         if bufsize < 0:
  21.             bufsize = self.default_bufsize
  22.         
  23.         self.bufsize = bufsize
  24.         self.softspace = False
  25.         if bufsize == 0:
  26.             self._rbufsize = 1
  27.         elif bufsize == 1:
  28.             self._rbufsize = self.default_bufsize
  29.         else:
  30.             self._rbufsize = bufsize
  31.         self._wbufsize = bufsize
  32.         self._rbuf = ''
  33.         self._wbuf = []
  34.  
  35.     
  36.     def _getclosed(self):
  37.         return self._sock is not None
  38.  
  39.     closed = property(_getclosed, doc = 'True if the file is closed')
  40.     
  41.     def close(self):
  42.         
  43.         try:
  44.             if self._sock:
  45.                 for result in self._sock._decrefAsync():
  46.                     pass
  47.                 
  48.         finally:
  49.             self._sock = None
  50.  
  51.  
  52.     
  53.     def __del__(self):
  54.         
  55.         try:
  56.             self.close()
  57.         except:
  58.             pass
  59.  
  60.  
  61.     
  62.     def flush(self):
  63.         if self._wbuf:
  64.             buffer = ''.join(self._wbuf)
  65.             self._wbuf = []
  66.             self._sock.sendall(buffer)
  67.         
  68.  
  69.     
  70.     def write(self, data):
  71.         data = str(data)
  72.         if not data:
  73.             return None
  74.         self._wbuf.append(data)
  75.         if not self._wbufsize == 0:
  76.             if self._wbufsize == 1 or '\n' in data or self._get_wbuf_len() >= self._wbufsize:
  77.                 self.flush()
  78.             
  79.  
  80.     
  81.     def writelines(self, list):
  82.         self._wbuf.extend(filter(None, map(str, list)))
  83.         if self._wbufsize <= 1 or self._get_wbuf_len() >= self._wbufsize:
  84.             self.flush()
  85.         
  86.  
  87.     
  88.     def _get_wbuf_len(self):
  89.         buf_len = 0
  90.         for x in self._wbuf:
  91.             buf_len += len(x)
  92.         
  93.         return buf_len
  94.  
  95.     
  96.     def read(self, size = -1):
  97.         data = self._rbuf
  98.         if size < 0:
  99.             buffers = []
  100.             if data:
  101.                 buffers.append(data)
  102.             
  103.             self._rbuf = ''
  104.             if self._rbufsize <= 1:
  105.                 recv_size = self.default_bufsize
  106.             else:
  107.                 recv_size = self._rbufsize
  108.             while True:
  109.                 data = self._sock.recv(recv_size)
  110.                 if not data:
  111.                     break
  112.                 
  113.                 buffers.append(data)
  114.             return ''.join(buffers)
  115.         buf_len = len(data)
  116.         if buf_len >= size:
  117.             self._rbuf = data[size:]
  118.             return data[:size]
  119.         buffers = []
  120.         self._rbuf = ''
  121.         while True:
  122.             left = size - buf_len
  123.             recv_size = max(self._rbufsize, left)
  124.             data = self._sock.recv(recv_size)
  125.             if not data:
  126.                 break
  127.             
  128.             buffers.append(data)
  129.             n = len(data)
  130.             if n >= left:
  131.                 self._rbuf = data[left:]
  132.                 buffers[-1] = data[:left]
  133.                 break
  134.             
  135.             buf_len += n
  136.         return ''.join(buffers)
  137.  
  138.     
  139.     def readline(self, size = -1):
  140.         data = self._rbuf
  141.         if size < 0:
  142.             if self._rbufsize <= 1:
  143.                 if not data == '':
  144.                     raise AssertionError
  145.                 buffers = []
  146.                 recv = self._sock.recv
  147.                 while data != '\n':
  148.                     data = recv(1)
  149.                     if not data:
  150.                         break
  151.                     
  152.                     buffers.append(data)
  153.                 return ''.join(buffers)
  154.             nl = data.find('\n')
  155.             if nl >= 0:
  156.                 nl += 1
  157.                 self._rbuf = data[nl:]
  158.                 return data[:nl]
  159.             buffers = []
  160.             self._rbuf = ''
  161.             while True:
  162.                 data = self._sock.recv(self._rbufsize)
  163.                 if not data:
  164.                     break
  165.                 
  166.                 buffers.append(data)
  167.                 nl = data.find('\n')
  168.                 if nl >= 0:
  169.                     nl += 1
  170.                     self._rbuf = data[nl:]
  171.                     buffers[-1] = data[:nl]
  172.                     break
  173.                     continue
  174.             return ''.join(buffers)
  175.         nl = data.find('\n', 0, size)
  176.         if nl >= 0:
  177.             nl += 1
  178.             self._rbuf = data[nl:]
  179.             return data[:nl]
  180.         buf_len = len(data)
  181.         if buf_len >= size:
  182.             self._rbuf = data[size:]
  183.             return data[:size]
  184.         buffers = []
  185.         self._rbuf = ''
  186.         while True:
  187.             data = self._sock.recv(self._rbufsize)
  188.             if not data:
  189.                 break
  190.             
  191.             buffers.append(data)
  192.             left = size - buf_len
  193.             nl = data.find('\n', 0, left)
  194.             if nl >= 0:
  195.                 nl += 1
  196.                 self._rbuf = data[nl:]
  197.                 buffers[-1] = data[:nl]
  198.                 break
  199.             
  200.             n = len(data)
  201.             if n >= left:
  202.                 self._rbuf = data[left:]
  203.                 buffers[-1] = data[:left]
  204.                 break
  205.             
  206.             buf_len += n
  207.         return ''.join(buffers)
  208.  
  209.     
  210.     def readlines(self, sizehint = 0):
  211.         total = 0
  212.         list = []
  213.         while True:
  214.             line = self.readline()
  215.             if not line:
  216.                 break
  217.             
  218.             list.append(line)
  219.             total += len(line)
  220.             if sizehint and total >= sizehint:
  221.                 break
  222.                 continue
  223.         return list
  224.  
  225.     
  226.     def __iter__(self):
  227.         return self
  228.  
  229.     
  230.     def next(self):
  231.         line = self.readline()
  232.         if not line:
  233.             raise StopIteration
  234.         line
  235.         return line
  236.  
  237.  
  238.